home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 1 / Cream of the Crop 1.iso / PROGRAM / DJINC106.ARJ / INTEGER.H < prev    next >
C/C++ Source or Header  |  1992-03-29  |  27KB  |  1,104 lines
  1. // This may look like C code, but it is really -*- C++ -*-
  2.  
  3. /* 
  4. Copyright (C) 1988 Free Software Foundation
  5.     written by Doug Lea (dl@rocky.oswego.edu)
  6.  
  7. This file is part of the GNU C++ Library.  This library is free
  8. software; you can redistribute it and/or modify it under the terms of
  9. the GNU Library General Public License as published by the Free
  10. Software Foundation; either version 2 of the License, or (at your
  11. option) any later version.  This library is distributed in the hope
  12. that it will be useful, but WITHOUT ANY WARRANTY; without even the
  13. implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  14. PURPOSE.  See the GNU Library General Public License for more details.
  15. You should have received a copy of the GNU Library General Public
  16. License along with this library; if not, write to the Free Software
  17. Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  18. */
  19.  
  20. #ifndef _Integer_h
  21. #ifdef __GNUG__
  22. #pragma interface
  23. #endif
  24. #define _Integer_h 1
  25.  
  26. #include <stream.h>
  27.  
  28. struct IntRep                    // internal Integer representations
  29. {
  30.   unsigned short  len;          // current length
  31.   unsigned short  sz;           // allocated space
  32.   short           sgn;          // 1 means >= 0; 0 means < 0 
  33.   unsigned short  s[1];         // represented as ushort array starting here
  34. };
  35.  
  36. extern IntRep*  Ialloc(IntRep*, const unsigned short *, int, int, int);
  37. extern IntRep*  Icalloc(IntRep*, int);
  38. extern IntRep*  Icopy_long(IntRep*, long);
  39. extern IntRep*  Icopy(IntRep*, const IntRep*);
  40. extern IntRep*  Iresize(IntRep*, int);
  41. extern IntRep*  add(const IntRep*, int, const IntRep*, int, IntRep*);
  42. extern IntRep*  add(const IntRep*, int, long, IntRep*);
  43. extern IntRep*  multiply(const IntRep*, const IntRep*, IntRep*);
  44. extern IntRep*  multiply(const IntRep*, long, IntRep*);
  45. extern IntRep*  lshift(const IntRep*, long, IntRep*);
  46. extern IntRep*  lshift(const IntRep*, const IntRep*, int, IntRep*);
  47. extern IntRep*  bitop(const IntRep*, const IntRep*, IntRep*, char);
  48. extern IntRep*  bitop(const IntRep*, long, IntRep*, char);
  49. extern IntRep*  power(const IntRep*, long, IntRep*);
  50. extern IntRep*  div(const IntRep*, const IntRep*, IntRep*);
  51. extern IntRep*  mod(const IntRep*, const IntRep*, IntRep*);
  52. extern IntRep*  div(const IntRep*, long, IntRep*);
  53. extern IntRep*  mod(const IntRep*, long, IntRep*);
  54. extern IntRep*  compl(const IntRep*, IntRep*);
  55. extern IntRep*  abs(const IntRep*, IntRep*);
  56. extern IntRep*  negate(const IntRep*, IntRep*);
  57. extern IntRep*  pow(const IntRep*, long);
  58. extern IntRep*  gcd(const IntRep*, const IntRep* y);
  59. extern int      compare(const IntRep*, const IntRep*);
  60. extern int      compare(const IntRep*, long);
  61. extern int      ucompare(const IntRep*, const IntRep*);
  62. extern int      ucompare(const IntRep*, long);
  63. extern char*    Itoa(const IntRep* x, int base = 10, int width = 0);
  64. extern char*    cvtItoa(const IntRep* x, char* fmt, int& fmtlen, int base,
  65.                         int showbase, int width, int align_right, 
  66.                         char fillchar, char Xcase, int showpos);
  67. extern IntRep*  atoIntRep(const char* s, int base = 10);
  68. extern long     Itolong(const IntRep*);
  69. extern double   Itodouble(const IntRep*);
  70. extern int      Iislong(const IntRep*);
  71. extern int      Iisdouble(const IntRep*);
  72. extern long     lg(const IntRep*);
  73.  
  74.  
  75. class Integer
  76. {
  77. protected:
  78.   IntRep*         rep;
  79. public:
  80.                   Integer();
  81.                   Integer(long);
  82.                   Integer(const Integer&);
  83.  
  84.                   ~Integer();
  85.  
  86.   void            operator =  (const Integer&);
  87.   void            operator =  (long);
  88.  
  89. // unary operations to self
  90.  
  91.   void            operator ++ ();
  92.   void            operator -- ();
  93.   void            negate();          // negate in-place
  94.   void            abs();             // absolute-value in-place
  95.   void            complement();      // bitwise complement in-place
  96.  
  97. // assignment-based operations
  98.  
  99.   void            operator += (const Integer&);
  100.   void            operator -= (const Integer&);
  101.   void            operator *= (const Integer&);
  102.   void            operator /= (const Integer&);
  103.   void            operator %= (const Integer&);
  104.   void            operator <<=(const Integer&);
  105.   void            operator >>=(const Integer&);
  106.   void            operator &= (const Integer&);
  107.   void            operator |= (const Integer&);
  108.   void            operator ^= (const Integer&);
  109.  
  110.   void            operator += (long);
  111.   void            operator -= (long);
  112.   void            operator *= (long);
  113.   void            operator /= (long);
  114.   void            operator %= (long);
  115.   void            operator <<=(long);
  116.   void            operator >>=(long);
  117.   void            operator &= (long);
  118.   void            operator |= (long);
  119.   void            operator ^= (long);
  120.  
  121. // (constructive binary operations are inlined below)
  122.  
  123. #ifdef __GNUG__
  124.   friend Integer operator <? (const Integer& x, const Integer& y); // min
  125.   friend Integer operator >? (const Integer& x, const Integer& y); // max
  126. #endif
  127.  
  128. // builtin Integer functions that must be friends
  129.  
  130.   friend long     lg (const Integer&); // floor log base 2 of abs(x)
  131.   friend double   ratio(const Integer& x, const Integer& y);
  132.                   // return x/y as a double
  133.  
  134.   friend Integer  gcd(const Integer&, const Integer&);
  135.   friend int      even(const Integer&); // true if even
  136.   friend int      odd(const Integer&); // true if odd
  137.   friend int      sign(const Integer&); // returns -1, 0, +1
  138.  
  139.   friend void     setbit(Integer& x, long b);   // set b'th bit of x
  140.   friend void     clearbit(Integer& x, long b); // clear b'th bit
  141.   friend int      testbit(const Integer& x, long b);  // return b'th bit
  142.  
  143. // procedural versions of operators
  144.  
  145.   friend void     abs(const Integer& x, Integer& dest);
  146.   friend void     negate(const Integer& x, Integer& dest);
  147.   friend void     complement(const Integer& x, Integer& dest);
  148.  
  149.   friend int      compare(const Integer&, const Integer&);  
  150.   friend int      ucompare(const Integer&, const Integer&); 
  151.   friend void     add(const Integer& x, const Integer& y, Integer& dest);
  152.   friend void     sub(const Integer& x, const Integer& y, Integer& dest);
  153.   friend void     mul(const Integer& x, const Integer& y, Integer& dest);
  154.   friend void     div(const Integer& x, const Integer& y, Integer& dest);
  155.   friend void     mod(const Integer& x, const Integer& y, Integer& dest);
  156.   friend void     divide(const Integer& x, const Integer& y, 
  157.                          Integer& q, Integer& r);
  158.   friend void     and(const Integer& x, const Integer& y, Integer& dest);
  159.   friend void     or(const Integer& x, const Integer& y, Integer& dest);
  160.   friend void     xor(const Integer& x, const Integer& y, Integer& dest);
  161.   friend void     lshift(const Integer& x, const Integer& y, Integer& dest);
  162.   friend void     rshift(const Integer& x, const Integer& y, Integer& dest);
  163.   friend void     pow(const Integer& x, const Integer& y, Integer& dest);
  164.  
  165.   friend int      compare(const Integer&, long);  
  166.   friend int      ucompare(const Integer&, long); 
  167.   friend void     add(const Integer& x, long y, Integer& dest);
  168.   friend void     sub(const Integer& x, long y, Integer& dest);
  169.   friend void     mul(const Integer& x, long y, Integer& dest);
  170.   friend void     div(const Integer& x, long y, Integer& dest);
  171.   friend void     mod(const Integer& x, long y, Integer& dest);
  172.   friend void     divide(const Integer& x, long y, Integer& q, long& r);
  173.   friend void     and(const Integer& x, long y, Integer& dest);
  174.   friend void     or(const Integer& x, long y, Integer& dest);
  175.   friend void     xor(const Integer& x, long y, Integer& dest);
  176.   friend void     lshift(const Integer& x, long y, Integer& dest);
  177.   friend void     rshift(const Integer& x, long y, Integer& dest);
  178.   friend void     pow(const Integer& x, long y, Integer& dest);
  179.  
  180.   friend int      compare(long, const Integer&);  
  181.   friend int      ucompare(long, const Integer&); 
  182.   friend void     add(long x, const Integer& y, Integer& dest);
  183.   friend void     sub(long x, const Integer& y, Integer& dest);
  184.   friend void     mul(long x, const Integer& y, Integer& dest);
  185.   friend void     and(long x, const Integer& y, Integer& dest);
  186.   friend void     or(long x, const Integer& y, Integer& dest);
  187.   friend void     xor(long x, const Integer& y, Integer& dest);
  188.  
  189. // coercion & conversion
  190.  
  191.   int             fits_in_long() const;
  192.   int             fits_in_double() const;
  193.  
  194.                   operator long() const;
  195.                   operator double() const;
  196.  
  197.   friend char*    Itoa(const Integer& x, int base = 10, int width = 0);
  198.   friend Integer  atoI(const char* s, int base = 10);
  199.   
  200.   friend istream& operator >> (istream& s, Integer& y);
  201.   friend ostream& operator << (ostream& s, const Integer& y);
  202.  
  203. // error detection
  204.  
  205.   int             initialized() const;
  206.   void   error(const char* msg) const;
  207.   int             OK() const;  
  208. };
  209.  
  210.  
  211. //  (These are declared inline)
  212.  
  213.   int      operator == (const Integer&, const Integer&);
  214.   int      operator == (const Integer&, long);
  215.   int      operator != (const Integer&, const Integer&);
  216.   int      operator != (const Integer&, long);
  217.   int      operator <  (const Integer&, const Integer&);
  218.   int      operator <  (const Integer&, long);
  219.   int      operator <= (const Integer&, const Integer&);
  220.   int      operator <= (const Integer&, long);
  221.   int      operator >  (const Integer&, const Integer&);
  222.   int      operator >  (const Integer&, long);
  223.   int      operator >= (const Integer&, const Integer&);
  224.   int      operator >= (const Integer&, long);
  225.   Integer  operator -  (const Integer&);
  226.   Integer  operator ~  (const Integer&);
  227.   Integer  operator +  (const Integer&, const Integer&);
  228.   Integer  operator +  (const Integer&, long);
  229.   Integer  operator +  (long, const Integer&);
  230.   Integer  operator -  (const Integer&, const Integer&);
  231.   Integer  operator -  (const Integer&, long);
  232.   Integer  operator -  (long, const Integer&);
  233.   Integer  operator *  (const Integer&, const Integer&);
  234.   Integer  operator *  (const Integer&, long);
  235.   Integer  operator *  (long, const Integer&);
  236.   Integer  operator /  (const Integer&, const Integer&);
  237.   Integer  operator /  (const Integer&, long);
  238.   Integer  operator %  (const Integer&, const Integer&);
  239.   Integer  operator %  (const Integer&, long);
  240.   Integer  operator << (const Integer&, const Integer&);
  241.   Integer  operator << (const Integer&, long);
  242.   Integer  operator >> (const Integer&, const Integer&);
  243.   Integer  operator >> (const Integer&, long);
  244.   Integer  operator &  (const Integer&, const Integer&);
  245.   Integer  operator &  (const Integer&, long);
  246.   Integer  operator &  (long, const Integer&);
  247.   Integer  operator |  (const Integer&, const Integer&);
  248.   Integer  operator |  (const Integer&, long);
  249.   Integer  operator |  (long, const Integer&);
  250.   Integer  operator ^  (const Integer&, const Integer&);
  251.   Integer  operator ^  (const Integer&, long);
  252.   Integer  operator ^  (long, const Integer&);
  253.  
  254.   Integer  abs(const Integer&); // absolute value
  255.   Integer  sqr(const Integer&); // square
  256.  
  257.   Integer  pow(const Integer& x, const Integer& y);
  258.   Integer  pow(const Integer& x, long y);
  259.   Integer  Ipow(long x, long y); // x to the y as Integer 
  260.  
  261.  
  262. extern char*    dec(const Integer& x, int width = 0);
  263. extern char*    oct(const Integer& x, int width = 0);
  264. extern char*    hex(const Integer& x, int width = 0);
  265. extern Integer  sqrt(const Integer&); // floor of square root
  266. extern Integer  lcm(const Integer& x, const Integer& y); // least common mult
  267.  
  268.  
  269. typedef Integer IntTmp; // for backward compatibility
  270.  
  271. inline Integer::Integer() :rep(0) {}
  272.  
  273. inline Integer::Integer(long y) :rep(Icopy_long(0, y)) {}
  274.  
  275. inline Integer::Integer(const Integer&  y) :rep(Icopy(0, y.rep)) {}
  276.  
  277. inline Integer::~Integer() { delete rep; }
  278.  
  279. inline void  Integer::operator = (const Integer&  y)
  280. {
  281.   rep = Icopy(rep, y.rep);
  282. }
  283.  
  284. inline void Integer::operator = (long y)
  285. {
  286.   rep = Icopy_long(rep, y); 
  287. }
  288.  
  289. inline Integer::operator long() const
  290. { 
  291.   return Itolong(rep);
  292. }
  293.  
  294. inline int Integer::initialized() const
  295. {
  296.   return rep != 0;
  297. }
  298.  
  299. inline int Integer::fits_in_long() const
  300. {
  301.   return Iislong(rep);
  302. }
  303.  
  304. inline Integer::operator double() const
  305. { 
  306.   return Itodouble(rep);
  307. }
  308.  
  309. inline int Integer::fits_in_double() const
  310. {
  311.   return Iisdouble(rep);
  312. }
  313.  
  314. // procedural versions
  315.  
  316. inline int compare(const Integer& x, const Integer& y)
  317. {
  318.   return compare(x.rep, y.rep);
  319. }
  320.  
  321. inline int ucompare(const Integer& x, const Integer& y)
  322. {
  323.   return ucompare(x.rep, y.rep);
  324. }
  325.  
  326. inline int compare(const Integer& x, long y)
  327. {
  328.   return compare(x.rep, y);
  329. }
  330.  
  331. inline int ucompare(const Integer& x, long y)
  332. {
  333.   return ucompare(x.rep, y);
  334. }
  335.  
  336. inline int compare(long x, const Integer& y)
  337. {
  338.   return -compare(y.rep, x);
  339. }
  340.  
  341. inline int ucompare(long x, const Integer& y)
  342. {
  343.   return -ucompare(y.rep, x);
  344. }
  345.  
  346. inline void  add(const Integer& x, const Integer& y, Integer& dest)
  347. {
  348.   dest.rep = add(x.rep, 0, y.rep, 0, dest.rep);
  349. }
  350.  
  351. inline void  sub(const Integer& x, const Integer& y, Integer& dest)
  352. {
  353.   dest.rep = add(x.rep, 0, y.rep, 1, dest.rep);
  354. }
  355.  
  356. inline void  mul(const Integer& x, const Integer& y, Integer& dest)
  357. {
  358.   dest.rep = multiply(x.rep, y.rep, dest.rep);
  359. }
  360.  
  361. inline void  div(const Integer& x, const Integer& y, Integer& dest)
  362. {
  363.   dest.rep = div(x.rep, y.rep, dest.rep);
  364. }
  365.  
  366. inline void  mod(const Integer& x, const Integer& y, Integer& dest)
  367. {
  368.   dest.rep = mod(x.rep, y.rep, dest.rep);
  369. }
  370.  
  371. inline void  and(const Integer& x, const Integer& y, Integer& dest)
  372. {
  373.   dest.rep = bitop(x.rep, y.rep, dest.rep, '&');
  374. }
  375.  
  376. inline void  or(const Integer& x, const Integer& y, Integer& dest)
  377. {
  378.   dest.rep = bitop(x.rep, y.rep, dest.rep, '|');
  379. }
  380.  
  381. inline void  xor(const Integer& x, const Integer& y, Integer& dest)
  382. {
  383.   dest.rep = bitop(x.rep, y.rep, dest.rep, '^');
  384. }
  385.  
  386. inline void  lshift(const Integer& x, const Integer& y, Integer& dest)
  387. {
  388.   dest.rep = lshift(x.rep, y.rep, 0, dest.rep);
  389. }
  390.  
  391. inline void  rshift(const Integer& x, const Integer& y, Integer& dest)
  392. {
  393.   dest.rep = lshift(x.rep, y.rep, 1, dest.rep);
  394. }
  395.  
  396. inline void  pow(const Integer& x, const Integer& y, Integer& dest)
  397. {
  398.   dest.rep = power(x.rep, long(y), dest.rep); // not incorrect
  399. }
  400.  
  401. inline void  add(const Integer& x, long y, Integer& dest)
  402. {
  403.   dest.rep = add(x.rep, 0, y, dest.rep);
  404. }
  405.  
  406. inline void  sub(const Integer& x, long y, Integer& dest)
  407. {
  408.   dest.rep = add(x.rep, 0, -y, dest.rep);
  409. }
  410.  
  411. inline void  mul(const Integer& x, long y, Integer& dest)
  412. {
  413.   dest.rep = multiply(x.rep, y, dest.rep);
  414. }
  415.  
  416. inline void  div(const Integer& x, long y, Integer& dest)
  417. {
  418.   dest.rep = div(x.rep, y, dest.rep);
  419. }
  420.  
  421. inline void  mod(const Integer& x, long y, Integer& dest)
  422. {
  423.   dest.rep = mod(x.rep, y, dest.rep);
  424. }
  425.  
  426. inline void  and(const Integer& x, long y, Integer& dest)
  427. {
  428.   dest.rep = bitop(x.rep, y, dest.rep, '&');
  429. }
  430.  
  431. inline void  or(const Integer& x, long y, Integer& dest)
  432. {
  433.   dest.rep = bitop(x.rep, y, dest.rep, '|');
  434. }
  435.  
  436. inline void  xor(const Integer& x, long y, Integer& dest)
  437. {
  438.   dest.rep = bitop(x.rep, y, dest.rep, '^');
  439. }
  440.  
  441. inline void  lshift(const Integer& x, long y, Integer& dest)
  442. {
  443.   dest.rep = lshift(x.rep, y, dest.rep);
  444. }
  445.  
  446. inline void  rshift(const Integer& x, long y, Integer& dest)
  447. {
  448.   dest.rep = lshift(x.rep, -y, dest.rep);
  449. }
  450.  
  451. inline void  pow(const Integer& x, long y, Integer& dest)
  452. {
  453.   dest.rep = power(x.rep, y, dest.rep);
  454. }
  455.  
  456. inline void abs(const Integer& x, Integer& dest)
  457. {
  458.   dest.rep = abs(x.rep, dest.rep);
  459. }
  460.  
  461. inline void negate(const Integer& x, Integer& dest)
  462. {
  463.   dest.rep = negate(x.rep, dest.rep);
  464. }
  465.  
  466. inline void complement(const Integer& x, Integer& dest)
  467. {
  468.   dest.rep = compl(x.rep, dest.rep);
  469. }
  470.  
  471. inline void  add(long x, const Integer& y, Integer& dest)
  472. {
  473.   dest.rep = add(y.rep, 0, x, dest.rep);
  474. }
  475.  
  476. inline void  sub(long x, const Integer& y, Integer& dest)
  477. {
  478.   dest.rep = add(y.rep, 1, x, dest.rep);
  479. }
  480.  
  481. inline void  mul(long x, const Integer& y, Integer& dest)
  482. {
  483.   dest.rep = multiply(y.rep, x, dest.rep);
  484. }
  485.  
  486. inline void  and(long x, const Integer& y, Integer& dest)
  487. {
  488.   dest.rep = bitop(y.rep, x, dest.rep, '&');
  489. }
  490.  
  491. inline void  or(long x, const Integer& y, Integer& dest)
  492. {
  493.   dest.rep = bitop(y.rep, x, dest.rep, '|');
  494. }
  495.  
  496. inline void  xor(long x, const Integer& y, Integer& dest)
  497. {
  498.   dest.rep = bitop(y.rep, x, dest.rep, '^');
  499. }
  500.  
  501.  
  502. // operator versions
  503.  
  504. inline int operator == (const Integer&  x, const Integer&  y)
  505. {
  506.   return compare(x, y) == 0; 
  507. }
  508.  
  509. inline int operator == (const Integer&  x, long y)
  510. {
  511.   return compare(x, y) == 0; 
  512. }
  513.  
  514. inline int operator != (const Integer&  x, const Integer&  y)
  515. {
  516.   return compare(x, y) != 0; 
  517. }
  518.  
  519. inline int operator != (const Integer&  x, long y)
  520. {
  521.   return compare(x, y) != 0; 
  522. }
  523.  
  524. inline int operator <  (const Integer&  x, const Integer&  y)
  525. {
  526.   return compare(x, y) <  0; 
  527. }
  528.  
  529. inline int operator <  (const Integer&  x, long y)
  530. {
  531.   return compare(x, y) <  0; 
  532. }
  533.  
  534. inline int operator <= (const Integer&  x, const Integer&  y)
  535. {
  536.   return compare(x, y) <= 0; 
  537. }
  538.  
  539. inline int operator <= (const Integer&  x, long y)
  540. {
  541.   return compare(x, y) <= 0; 
  542. }
  543.  
  544. inline int operator >  (const Integer&  x, const Integer&  y)
  545. {
  546.   return compare(x, y) >  0; 
  547. }
  548.  
  549. inline int operator >  (const Integer&  x, long y)
  550. {
  551.   return compare(x, y) >  0; 
  552. }
  553.  
  554. inline int operator >= (const Integer&  x, const Integer&  y)
  555. {
  556.   return compare(x, y) >= 0; 
  557. }
  558.  
  559. inline int operator >= (const Integer&  x, long y)
  560. {
  561.   return compare(x, y) >= 0; 
  562. }
  563.  
  564.  
  565. inline void  Integer::operator += (const Integer& y)
  566. {
  567.   add(*this, y, *this);
  568. }
  569.  
  570. inline void  Integer::operator += (long y)
  571. {
  572.   add(*this, y, *this);
  573. }
  574.  
  575. inline void Integer::operator ++ ()
  576. {
  577.   add(*this, 1, *this);
  578. }
  579.  
  580.  
  581. inline void  Integer::operator -= (const Integer& y)
  582. {
  583.   sub(*this, y, *this);
  584. }
  585.  
  586. inline void  Integer::operator -= (long y)
  587. {
  588.   sub(*this, y, *this);
  589. }
  590.  
  591. inline void Integer::operator -- ()
  592. {
  593.   add(*this, -1, *this);
  594. }
  595.  
  596.  
  597.  
  598. inline void Integer::operator *= (const Integer& y)
  599. {
  600.   mul(*this, y, *this);
  601. }
  602.  
  603. inline void Integer::operator *= (long y)
  604. {
  605.   mul(*this, y, *this);
  606. }
  607.  
  608.  
  609. inline void  Integer::operator &= (const Integer& y)
  610. {
  611.   and(*this, y, *this);
  612. }
  613.  
  614. inline void  Integer::operator &= (long y)
  615. {
  616.   and(*this, y, *this);
  617. }
  618.  
  619. inline void  Integer::operator |= (const Integer& y)
  620. {
  621.   or(*this, y, *this);
  622. }
  623.  
  624. inline void  Integer::operator |= (long y)
  625. {
  626.   or(*this, y, *this);
  627. }
  628.  
  629.  
  630. inline void  Integer::operator ^= (const Integer& y)
  631. {
  632.   xor(*this, y, *this);
  633. }
  634.  
  635. inline void  Integer::operator ^= (long y)
  636. {
  637.   xor(*this, y, *this);
  638. }
  639.  
  640.  
  641.  
  642. inline void Integer::operator /= (const Integer& y)
  643. {
  644.   div(*this, y, *this);
  645. }
  646.  
  647. inline void Integer::operator /= (long y)
  648. {
  649.   div(*this, y, *this);
  650. }
  651.  
  652.  
  653. inline void Integer::operator %= (const Integer& y)
  654. {
  655.   mod(*this, y, *this);
  656. }
  657.  
  658. inline void Integer::operator %= (long y)
  659. {
  660.   mod(*this, y, *this);
  661. }
  662.  
  663.  
  664. inline void Integer::operator <<= (const Integer&  y)
  665. {
  666.   lshift(*this, y, *this);
  667. }
  668.  
  669. inline void Integer::operator <<= (long  y)
  670. {
  671.   lshift(*this, y, *this);
  672. }
  673.  
  674.  
  675. inline void Integer::operator >>= (const Integer&  y)
  676. {
  677.   rshift(*this, y, *this);
  678. }
  679.  
  680. inline void  Integer::operator >>= (long y)
  681. {
  682.   rshift(*this, y, *this);
  683. }
  684.  
  685. #ifdef __GNUG__
  686. inline Integer operator <? (const Integer& x, const Integer& y)
  687. {
  688.   return (compare(x.rep, y.rep) <= 0) ? x : y;
  689. }
  690.  
  691. inline Integer operator >? (const Integer& x, const Integer& y)
  692. {
  693.   return (compare(x.rep, y.rep) >= 0)?  x : y;
  694. }
  695. #endif
  696.  
  697.  
  698. inline void Integer::abs()
  699. {
  700.   ::abs(*this, *this);
  701. }
  702.  
  703. inline void Integer::negate()
  704. {
  705.   ::negate(*this, *this);
  706. }
  707.  
  708.  
  709. inline void Integer::complement()
  710. {
  711.   ::complement(*this, *this);
  712. }
  713.  
  714.  
  715. inline int sign(const Integer& x)
  716. {
  717.   return (x.rep->len == 0) ? 0 : ( (x.rep->sgn == 1) ? 1 : -1 );
  718. }
  719.  
  720. inline int even(const Integer& y)
  721. {
  722.   return y.rep->len == 0 || !(y.rep->s[0] & 1);
  723. }
  724.  
  725. inline int odd(const Integer& y)
  726. {
  727.   return y.rep->len > 0 && (y.rep->s[0] & 1);
  728. }
  729.  
  730. inline char* Itoa(const Integer& y, int base, int width)
  731. {
  732.   return Itoa(y.rep, base, width);
  733. }
  734.  
  735.  
  736.  
  737. inline long lg(const Integer& x) 
  738. {
  739.   return lg(x.rep);
  740. }
  741.  
  742. // constructive operations 
  743.  
  744. #if defined(__GNUG__) && !defined(NO_NRV)
  745.  
  746. inline Integer  operator +  (const Integer& x, const Integer& y) return r
  747. {
  748.   add(x, y, r);
  749. }
  750.  
  751. inline Integer  operator +  (const Integer& x, long y) return r
  752. {
  753.   add(x, y, r);
  754. }
  755.  
  756. inline Integer  operator +  (long  x, const Integer& y) return r
  757. {
  758.   add(x, y, r);
  759. }
  760.  
  761. inline Integer  operator -  (const Integer& x, const Integer& y) return r
  762. {
  763.   sub(x, y, r);
  764. }
  765.  
  766. inline Integer  operator -  (const Integer& x, long y) return r
  767. {
  768.   sub(x, y, r);
  769. }
  770.  
  771. inline Integer  operator -  (long  x, const Integer& y) return r
  772. {
  773.   sub(x, y, r);
  774. }
  775.  
  776. inline Integer  operator *  (const Integer& x, const Integer& y) return r
  777. {
  778.   mul(x, y, r);
  779. }
  780.  
  781. inline Integer  operator *  (const Integer& x, long y) return r
  782. {
  783.   mul(x, y, r);
  784. }
  785.  
  786. inline Integer  operator *  (long  x, const Integer& y) return r
  787. {
  788.   mul(x, y, r);
  789. }
  790.  
  791. inline Integer sqr(const Integer& x) return r
  792. {
  793.   mul(x, x, r);
  794. }
  795.  
  796. inline Integer  operator &  (const Integer& x, const Integer& y) return r
  797. {
  798.   and(x, y, r);
  799. }
  800.  
  801. inline Integer  operator &  (const Integer& x, long y) return r
  802. {
  803.   and(x, y, r);
  804. }
  805.  
  806. inline Integer  operator &  (long  x, const Integer& y) return r
  807. {
  808.   and(x, y, r);
  809. }
  810.  
  811. inline Integer  operator |  (const Integer& x, const Integer& y) return r
  812. {
  813.   or(x, y, r);
  814. }
  815.  
  816. inline Integer  operator |  (const Integer& x, long y) return r
  817. {
  818.   or(x, y, r);
  819. }
  820.  
  821. inline Integer  operator |  (long  x, const Integer& y) return r
  822. {
  823.   or(x, y, r);
  824. }
  825.  
  826. inline Integer  operator ^  (const Integer& x, const Integer& y) return r
  827. {
  828.   xor(x, y, r);
  829. }
  830.  
  831. inline Integer  operator ^  (const Integer& x, long y) return r
  832. {
  833.   xor(x, y, r);
  834. }
  835.  
  836. inline Integer  operator ^  (long  x, const Integer& y) return r
  837. {
  838.   xor(x, y, r);
  839. }
  840.  
  841. inline Integer  operator /  (const Integer& x, const Integer& y) return r
  842. {
  843.   div(x, y, r);
  844. }
  845.  
  846. inline Integer operator /  (const Integer& x, long y) return r
  847. {
  848.   div(x, y, r);
  849. }
  850.  
  851. inline Integer operator %  (const Integer& x, const Integer& y) return r
  852. {
  853.   mod(x, y, r);
  854. }
  855.  
  856. inline Integer operator %  (const Integer& x, long y) return r
  857. {
  858.   mod(x, y, r);
  859. }
  860.  
  861. inline Integer operator <<  (const Integer& x, const Integer& y) return r
  862. {
  863.   lshift(x, y, r);
  864. }
  865.  
  866. inline Integer operator <<  (const Integer& x, long y) return r
  867. {
  868.   lshift(x, y, r);
  869. }
  870.  
  871. inline Integer operator >>  (const Integer& x, const Integer& y) return r;
  872. {
  873.   rshift(x, y, r);
  874. }
  875.  
  876. inline Integer operator >>  (const Integer& x, long y) return r
  877. {
  878.   rshift(x, y, r);
  879. }
  880.  
  881. inline Integer pow(const Integer& x, long y) return r
  882. {
  883.   pow(x, y, r);
  884. }
  885.  
  886. inline Integer Ipow(long x, long y) return r(x)
  887. {
  888.   pow(r, y, r);
  889. }
  890.  
  891. inline Integer pow(const Integer& x, const Integer& y) return r
  892. {
  893.   pow(x, y, r);
  894. }
  895.  
  896.  
  897.  
  898. inline Integer abs(const Integer& x) return r
  899. {
  900.   abs(x, r);
  901. }
  902.  
  903. inline Integer operator - (const Integer& x) return r
  904. {
  905.   negate(x, r);
  906. }
  907.  
  908. inline Integer operator ~ (const Integer& x) return r
  909. {
  910.   complement(x, r);
  911. }
  912.  
  913. inline Integer  atoI(const char* s, int base) return r
  914. {
  915.   r.rep = atoIntRep(s, base);
  916. }
  917.  
  918. inline Integer  gcd(const Integer& x, const Integer& y) return r
  919. {
  920.   r.rep = gcd(x.rep, y.rep);
  921. }
  922.  
  923. #else /* NO_NRV */
  924.  
  925. inline Integer  operator +  (const Integer& x, const Integer& y) 
  926. {
  927.   Integer r; add(x, y, r); return r;
  928. }
  929.  
  930. inline Integer  operator +  (const Integer& x, long y) 
  931. {
  932.   Integer r; add(x, y, r); return r;
  933. }
  934.  
  935. inline Integer  operator +  (long  x, const Integer& y) 
  936. {
  937.   Integer r; add(x, y, r); return r;
  938. }
  939.  
  940. inline Integer  operator -  (const Integer& x, const Integer& y) 
  941. {
  942.   Integer r; sub(x, y, r); return r;
  943. }
  944.  
  945. inline Integer  operator -  (const Integer& x, long y) 
  946. {
  947.   Integer r; sub(x, y, r); return r;
  948. }
  949.  
  950. inline Integer  operator -  (long  x, const Integer& y) 
  951. {
  952.   Integer r; sub(x, y, r); return r;
  953. }
  954.  
  955. inline Integer  operator *  (const Integer& x, const Integer& y) 
  956. {
  957.   Integer r; mul(x, y, r); return r;
  958. }
  959.  
  960. inline Integer  operator *  (const Integer& x, long y) 
  961. {
  962.   Integer r; mul(x, y, r); return r;
  963. }
  964.  
  965. inline Integer  operator *  (long  x, const Integer& y) 
  966. {
  967.   Integer r; mul(x, y, r); return r;
  968. }
  969.  
  970. inline Integer sqr(const Integer& x) 
  971. {
  972.   Integer r; mul(x, x, r); return r;
  973. }
  974.  
  975. inline Integer  operator &  (const Integer& x, const Integer& y) 
  976. {
  977.   Integer r; and(x, y, r); return r;
  978. }
  979.  
  980. inline Integer  operator &  (const Integer& x, long y) 
  981. {
  982.   Integer r; and(x, y, r); return r;
  983. }
  984.  
  985. inline Integer  operator &  (long  x, const Integer& y) 
  986. {
  987.   Integer r; and(x, y, r); return r;
  988. }
  989.  
  990. inline Integer  operator |  (const Integer& x, const Integer& y) 
  991. {
  992.   Integer r; or(x, y, r); return r;
  993. }
  994.  
  995. inline Integer  operator |  (const Integer& x, long y) 
  996. {
  997.   Integer r; or(x, y, r); return r;
  998. }
  999.  
  1000. inline Integer  operator |  (long  x, const Integer& y) 
  1001. {
  1002.   Integer r; or(x, y, r); return r;
  1003. }
  1004.  
  1005. inline Integer  operator ^  (const Integer& x, const Integer& y) 
  1006. {
  1007.   Integer r; xor(x, y, r); return r;
  1008. }
  1009.  
  1010. inline Integer  operator ^  (const Integer& x, long y) 
  1011. {
  1012.   Integer r; xor(x, y, r); return r;
  1013. }
  1014.  
  1015. inline Integer  operator ^  (long  x, const Integer& y) 
  1016. {
  1017.   Integer r; xor(x, y, r); return r;
  1018. }
  1019.  
  1020. inline Integer  operator /  (const Integer& x, const Integer& y) 
  1021. {
  1022.   Integer r; div(x, y, r); return r;
  1023. }
  1024.  
  1025. inline Integer operator /  (const Integer& x, long y) 
  1026. {
  1027.   Integer r; div(x, y, r); return r;
  1028. }
  1029.  
  1030. inline Integer operator %  (const Integer& x, const Integer& y) 
  1031. {
  1032.   Integer r; mod(x, y, r); return r;
  1033. }
  1034.  
  1035. inline Integer operator %  (const Integer& x, long y) 
  1036. {
  1037.   Integer r; mod(x, y, r); return r;
  1038. }
  1039.  
  1040. inline Integer operator <<  (const Integer& x, const Integer& y) 
  1041. {
  1042.   Integer r; lshift(x, y, r); return r;
  1043. }
  1044.  
  1045. inline Integer operator <<  (const Integer& x, long y) 
  1046. {
  1047.   Integer r; lshift(x, y, r); return r;
  1048. }
  1049.  
  1050. inline Integer operator >>  (const Integer& x, const Integer& y) 
  1051. {
  1052.   Integer r; rshift(x, y, r); return r;
  1053. }
  1054.  
  1055. inline Integer operator >>  (const Integer& x, long y) 
  1056. {
  1057.   Integer r; rshift(x, y, r); return r;
  1058. }
  1059.  
  1060. inline Integer pow(const Integer& x, long y) 
  1061. {
  1062.   Integer r; pow(x, y, r); return r;
  1063. }
  1064.  
  1065. inline Integer Ipow(long x, long y) 
  1066. {
  1067.   Integer r(x); pow(r, y, r); return r;
  1068. }
  1069.  
  1070. inline Integer pow(const Integer& x, const Integer& y) 
  1071. {
  1072.   Integer r; pow(x, y, r); return r;
  1073. }
  1074.  
  1075.  
  1076.  
  1077. inline Integer abs(const Integer& x) 
  1078. {
  1079.   Integer r; abs(x, r); return r;
  1080. }
  1081.  
  1082. inline Integer operator - (const Integer& x) 
  1083. {
  1084.   Integer r; negate(x, r); return r;
  1085. }
  1086.  
  1087. inline Integer operator ~ (const Integer& x) 
  1088. {
  1089.   Integer r; complement(x, r); return r;
  1090. }
  1091.  
  1092. inline Integer  atoI(const char* s, int base) 
  1093. {
  1094.   Integer r; r.rep = atoIntRep(s, base); return r;
  1095. }
  1096.  
  1097. inline Integer  gcd(const Integer& x, const Integer& y) 
  1098. {
  1099.   Integer r; r.rep = gcd(x.rep, y.rep); return r;
  1100. }
  1101.  
  1102. #endif  /* NO_NRV */
  1103. #endif /* !_Integer_h */
  1104.